package com.stars.common.result;

import com.google.gson.Gson;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 
 * @description 转换工具类,请注意驼峰命名的使用方法
 * @author alex
 * @time 2016年11月18日 上午10:14:41
 * @version 1.0
 */
public class Conversion {

	/**
	 * 
	 * @description 驼峰命名转换成数据库命名
	 * @author alex
	 * @param str
	 *            驼峰命名转换数据库名称的字符串
	 * @return 驼峰命名大写转换:'_'+小写,例子:usersName转换成users_name
	 */
	public static String convertString(String str) {
		if (StringUtils.isEmpty(str))
			return "";
		String upStr = str.toUpperCase();
		String lowStr = str.toLowerCase();
		StringBuffer buf = new StringBuffer(str.length());
		for (int i = 0; i < str.length(); i++) {
			if (str.charAt(i) == upStr.charAt(i)) {
				buf.append("_" + lowStr.charAt(i));
			} else {
				buf.append(lowStr.charAt(i));
			}
		}
		return buf.toString();
	}

	/**
	 * @description 传入一个字符串返回字符串中的大写字母
	 * @author alex
	 * @return 返回一个字符串中的大写字母
	 */
	public static String stringChange(String s) {
		if (StringUtils.isEmpty(s))
			return "";
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < s.length(); i++) {
			if (Character.isUpperCase(s.charAt(i))) {
				sb.append(s.charAt(i));
			}
		}
		return sb.toString();
	}

	/**
	 * 1、若str为空，返回空；2、str不为空，左边参数存在，拼接左边参数；2、str不为空，右边参数存在，拼接右边参数
	 * 
	 * @description 字符串左边或者右边拼接
	 * @author alex
	 * @param str
	 *            需要拼接的字符串
	 * @param left
	 *            字符串左边拼接
	 * @param right
	 *            字符串右边拼接
	 * @return 返回null或者拼接后的字符串
	 */
	public static String strAppend(String str, String left, String right) {
		if (StringUtils.isEmpty(str)) {
			// 需要拼接的字符串为空
			return null;
		}
		StringBuffer sb = new StringBuffer();
		if (!StringUtils.isEmpty(left)) {
			// 左边拼接参数不为空,进行拼接
			sb.append(left);
		}
		sb.append(str);
		if (!StringUtils.isEmpty(right)) {
			// 右边拼接参数不为空,进行拼接
			sb.append(right);
		}
		return sb.toString();
	}

	/**
	 * 
	 * @description 左右，加%进行模糊查询
	 * @author alex
	 * @param str
	 * @return
	 */
	public static String likeAll(String str) {
		return strAppend(str, "%", "%");
	}

	/**
	 * 
	 * @description 左边,加%进行模糊查询
	 * @author alex
	 * @param str
	 * @return
	 */
	public static String likeLeft(String str) {
		return strAppend(str, "%", null);
	}

	/**
	 * 
	 * @description 右边,加%进行模糊查询
	 * @author alex
	 * @param str
	 * @return
	 */
	public static String likeRight(String str) {
		return strAppend(str, null, "%");
	}

	/**
	 * 
	 * @description 输入流转换成字符串(InputStream转换成String)()
	 * @author alex
	 * @date 2016年12月20日 下午4:20:20
	 * @version 1.0.0
	 * @param is
	 * @return
	 * @throws IOException
	 */
	public static String conversionToString(InputStream is) throws IOException {
		BufferedReader reader = new BufferedReader(new InputStreamReader(is));
		StringBuilder sb = new StringBuilder();
		String line = null;
		while ((line = reader.readLine()) != null) {
			// sb.append(line + "/n");
			sb.append(line);
		}
//		System.out.println(sb.toString());
		return sb.toString();
	}

	/**
	 * 
	 * @description xml字符串转换成map集合,仅适合单节点root
	 * @author alex
	 * @date 2016年12月20日 下午4:24:18
	 * @version 1.0.0
	 * @param str
	 * @return
	 * @throws DocumentException
	 */
	@SuppressWarnings("unchecked")
	public static Map<String, Object> conversionToMap(String str) throws DocumentException {
		Map<String, Object> map = new HashMap<String, Object>();
		Document document = DocumentHelper.parseText(str);
		Element root = document.getRootElement();
		List<Element> eles = root.elements();
		for (Element e : eles) {
			map.put(e.getName(), e.getTextTrim());
		}
//		System.out.println("xml字符串转换成map:" + map);
		return map;
	}
	


	/**
	 * 
	 * @description 字符串算术,特别注意:运算后将保留前置的0(保留的是算数值前置的0),例子:(算数值)(运算法则)(被算数值) = 结果
	 * @author alex
	 * @date 2017年2月8日 上午11:25:00
	 * @version 1.0.0
	 * @param value
	 *            算数值
	 * @param type
	 *            运算法则
	 * @param count
	 *            被算数值
	 * @return
	 */
	public static String stringToArithmetic(String value, String type, String count) {
		String reString = null;
		try {
			String zero = null;
			/** 正则表达式匹配第一个非0数字出现的位置 **/
			Pattern pattern = Pattern.compile("[1-9]");
			Matcher matcher = pattern.matcher(value);
			if (matcher.find()) {
				/** 获取前面的0,截取(0,正则表达式匹配第一个非0数字出现的位置) **/
				zero = value.substring(0, value.indexOf(matcher.group()));
			}
			BigDecimal bigdValue = new BigDecimal(value);
			BigDecimal bigdCount = new BigDecimal(count);
			/** 根据type确定使用什么运算法则 **/
			switch (type) {
			case "add":
				/** 加 **/
				reString = bigdValue.add(bigdCount).toString();
				break;
			case "subtract":
				/** 减 **/
				reString = bigdValue.subtract(bigdCount).toString();
				break;
			case "multiply":
				/** 乘 **/
				reString = bigdValue.multiply(bigdCount).toString();
				break;
			case "divide":
				/** 除,注意,当bigDecimal除不尽时，会抛出异常。正确的做法是:四舍五入保留小数点后2位 **/
				reString = bigdValue.divide(bigdCount,2, BigDecimal.ROUND_HALF_EVEN).toString()+"";
				break;
			}
			return zero+reString;
		} catch (Exception e) {
			e.printStackTrace();
			return reString;
		}
	}

	/**
	 *
	 * @description 向接口外部输出json
	 * @author alex
	 * @date 2017年4月20日 上午10:08:27
	 * @version 1.0.0
	 * @param response
	 * @throws IOException
	 */
	public static void outPrint(HttpServletResponse response,Object obj) throws IOException{
		Gson gson = new Gson();
		String jsonStr = gson.toJson(obj);
		response.setCharacterEncoding("UTF-8");
		response.setContentType("application/json; charset=utf-8");
		PrintWriter out = null;
		out = response.getWriter();
		out.append(jsonStr);
	}

}
